Node.js இல் தொகுதி என்றால் என்ன?

தொகுதிகள் Node.js பயன்பாடுகளின் கட்டுமானத் தொகுதிகள் ஆகும், இவை குறியீட்டை தர்க்கரீதியான, மீண்டும் பயன்படுத்தக்கூடிய கூறுகளாக ஒழுங்கமைக்க உங்களை அனுமதிக்கின்றன. இவை பின்வருவனவற்றில் உதவுகின்றன:

முக்கிய உள்ளமைக்கப்பட்ட தொகுதிகள்

Node.js பைனரியில் தொகுக்கப்பட்ட பல உள்ளமைக்கப்பட்ட தொகுதிகளை வழங்குகிறது.

இங்கே பொதுவாகப் பயன்படுத்தப்படும் சிலவை உள்ளன:

const http = require('http');

http.createServer((req, res) => {
  res.writeHead(200, {'Content-Type': 'text/html'});
  res.end('Hello World!');
}).listen(8080);

தொகுதிகளை உருவாக்குதல் மற்றும் ஏற்றுமதி செய்தல்

Node.js இல், .js நீட்டிப்பு கொண்ட எந்த கோப்பும் ஒரு தொகுதியாகும். நீங்கள் பல வழிகளில் ஒரு தொகுதியிலிருந்து செயல்பாட்டை ஏற்றுமதி செய்யலாம்:

// Exporting multiple functions
const getCurrentDate = () => new Date().toISOString();

const formatCurrency = (amount, currency = 'USD') => {
  return new Intl.NumberFormat('en-US', {
    style: 'currency',
    currency: currency
  }).format(amount);
};

// Method 1: Exporting multiple items
exports.getCurrentDate = getCurrentDate;
exports.formatCurrency = formatCurrency;

// Method 2: Exporting an object with multiple properties
// module.exports = { getCurrentDate, formatCurrency };

class Logger {
  constructor(name) {
    this.name = name;
  }

  log(message) {
    console.log(`[${this.name}] ${message}`);
  }

  error(error) {
    console.error(`[${this.name}] ERROR:`, error.message);
  }
}

// Exporting a single class
module.exports = Logger;

உங்கள் தொகுதிகளைப் பயன்படுத்துதல்

ஒரு தொடர்புடைய அல்லது முழுமையான பாதையுடன் require() ஐப் பயன்படுத்தி உங்கள் தனிப்பயன் தொகுதிகளை இறக்குமதி செய்து பயன்படுத்தவும்:

const http = require('http');
const path = require('path');

// Importing custom modules
const { getCurrentDate, formatCurrency } = require('./utils');
const Logger = require('./logger');

// Create a logger instance
const logger = new Logger('App');

// Create server
const server = http.createServer((req, res) => {
  try {
    logger.log(`Request received for ${req.url}`);

    res.writeHead(200, { 'Content-Type': 'text/html' });
    res.write(`
Welcome to our app!
`);
    res.write(`
Current date: ${getCurrentDate()}
`);
    res.write(`
Formatted amount: ${formatCurrency(99.99)}
`);
    res.end();
  } catch (error) {
    logger.error(error);
    res.writeHead(500, { 'Content-Type': 'text/plain' });
    res.end('Internal Server Error');
  }
});

// Start server
const PORT = process.env.PORT || 3000;
server.listen(PORT, () => {
  logger.log(`Server running at http://localhost:${PORT}`);
});

தொகுதி ஏற்றுதல் மற்றும் தற்காலிக சேமிப்பு

Node.js தொகுதிகள் முதல் முறையாக ஏற்றப்பட்ட பிறகு அவற்றை தற்காலிகமாக சேமிக்கிறது. இதன் பொருள், அடுத்தடுத்த require() அழைப்புகள் தற்காலிகமாக சேமிக்கப்பட்ட பதிப்பை வழங்குகின்றன.

சிறந்த நடைமுறைகள்

சுருக்கம்

தொகுதிகள் Node.js இல் ஒரு முக்கிய கருத்தாகும். அவை குறியீட்டை மீண்டும் பயன்படுத்தக்கூடிய, பராமரிக்கக்கூடிய அலகுகளாக ஒழுங்கமைக்க உங்களை இயக்குகின்றன.

தொகுதிகளை திறம்பட உருவாக்க, ஏற்றுமதி செய்தல் மற்றும் பயன்படுத்துதல் ஆகியவற்றைப் புரிந்துகொள்வதன் மூலம், நீங்கள் அளவிடக்கூடிய மற்றும் நன்கு கட்டமைக்கப்பட்ட பயன்பாடுகளை உருவாக்கலாம்.

பயிற்சி